Introduction to Artificial Neural Networks (ANN)
Artificial Neural Networks (ANN) are computing systems inspired by
the biological neural networks of animal brains. These models are
designed to simulate the way the human brain processes
information, making them exceptionally good at modeling and
solving complex problems by learning from data.
Applications of ANNs
ANNs are applied in a wide range of real-world scenarios, some
of which include:
-
Netflix content recommendation: Uses ANNs to
analyze your viewing history and preferences to recommend
movies and shows you’re likely to enjoy.
-
Instagram feed: Employs deep learning
algorithms to personalize your feed, showing you content that
is more relevant to your interests.
-
Handwritten digit recognition: ANNs can
identify and classify handwritten numbers, a technology used
in document digitization and character recognition.
-
FaceID technology: Utilizes advanced ANNs for
secure and accurate facial recognition, allowing you to unlock
your device by simply looking at it.
These examples demonstrate the versatility and the ability of
ANNs to learn from large datasets and perform tasks that would
require human intelligence.
Exercise 1: Did I Pass the Subject?
This exercise focuses on using an ANN to predict whether a
student has passed a subject based on their academic features,
such as grades obtained in assignments, midterm exams, and class
attendance.
1. Install Packages and Call Libraries
Before we start working with artificial neural networks in R,
it’s crucial to have the neuralnet package
installed and loaded. This package allows us to efficiently
train and simulate artificial neural networks in R with a
relatively straightforward syntax. The following code chunk
first checks if the neuralnet package is installed,
installing it if necessary. Then, it loads the package using
library(neuralnet), enabling us to access its
functions and use them in our analysis.
Ensure you have an active internet connection if you need to
install the package, as install.packages will
download the package from CRAN.
# install.packages("dplyr")
# install.packages("neuralnet")
library(dplyr)
##
## Attaching package: 'dplyr'
## The following objects are masked from 'package:stats':
##
## filter, lag
## The following objects are masked from 'package:base':
##
## intersect, setdiff, setequal, union
library(neuralnet)
##
## Attaching package: 'neuralnet'
## The following object is masked from 'package:dplyr':
##
## compute
2. Obtain Data
We are constructing a data frame named df that
contains three columns: exam, proyect,
and status. Each of these columns represents
different aspects of a dataset that could be related to student
assessments or project evaluations:
-
The exam column contains numeric scores or
values associated with exams, with each entry representing a
different individual or instance.
-
The proyect column (presumably intended to
spell “project”) includes scores or values related to
projects. Like the exam column, each entry here
pertains to a different individual or instance.
-
The status column uses binary values (1 or 0)
to indicate a particular state or condition for each entry.
This could represent a pass/fail status, completion, or any
other binary indicator relevant to the context of the data.
The code below combines these vectors into a single data frame,
providing a structured and tabular representation of the data
for further analysis or visualization.
exam<-c(20,10,30,20,80,30)
proyect<-c(90,20,40,50,50,80)
status<-c(1,0,0,0,0,1)
df<-data.frame(exam,proyect,status)
3. Generate Neural Network
We’re applying a neural network model to predict the
status based on exam and
proyect scores using the
neuralnet package. This model helps us understand
the relationship between exam/project scores and their status
outcomes. After training the model with
nn1 <- neuralnet(status ~., data=df), we
visualize it using
plot(nn1, rep="best") to inspect the
network structure and how inputs are related to the prediction.
nn1 <- neuralnet(status ~., data=df)
plot(nn1, rep="best")
4. Predict Results
Now that our neural network model is trained, we proceed to
evaluate its predictive performance using a new set of exam and
project scores. This step is essential for assessing the model’s
ability to generalize and make accurate predictions on data it
hasn’t seen before. By inputting these new scores into the
model, we aim to predict their corresponding statuses, providing
insights into how well our model can apply learned patterns to
real-world or hypothetical scenarios. This evaluation phase is
crucial for understanding the practical applicability of our
neural network in predicting outcomes based on exam and project
performances.
exam_test<-c(30,40,85)
proyect_test<-c(85,50,40)
test1 <- data_frame(exam_test,proyect_test)
## Warning: `data_frame()` was deprecated in tibble 1.1.0.
## ℹ Please use `tibble()` instead.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.
prediction <- compute(nn1,test1)
prediction$net.result
## [,1]
## [1,] 1.01126893
## [2,] 0.01946212
## [3,] -0.01891719
1. Install Packages and Call Libraries
Before diving into our analysis, it’s crucial to ensure that all
necessary packages are installed and loaded into our R
environment. This step lays the groundwork for a smooth analysis
process, allowing us to utilize various functions and tools
provided by these packages. Specifically, we focus on two
packages:
-
readr: Facilitates efficient reading of rectangular data, such as
CSV files. Its fast and friendly syntax makes it a go-to
choice for data import in R.
-
caret: Stands for Classification And REgression Training.
This package provides a comprehensive suite of tools to create
complex predictive models. It simplifies the process of
training and tuning machine learning models, making it
invaluable for predictive analytics.
By loading these libraries, we ensure that our R session is
equipped with the necessary tools for data importation,
preprocessing, and advanced modeling techniques.
# install.packages("readr")
# install.packages("caret")
library(readr)
library(caret)
2. Obtain Data
After setting up our environment with the necessary libraries,
our next step involves loading and preparing the dataset for
analysis. We’re focusing on a dataset named
cancer_de_mama.csv, which includes data pertinent
to breast cancer diagnosis. The preparation process involves
several key steps to ensure the data is suitable for training a
machine learning model:
-
Loading the Dataset: We use the
read_csv function from the
readr package to load the
cancer_de_mama.csv file. This function is
optimized for fast and efficient loading of CSV files into
R.
-
Encoding the Diagnosis: The dataset
includes a diagnosis column with categorical values (M
for malignant, B for benign). We convert these
into binary numeric values (1 for malignant, 0 for benign)
to facilitate the modeling process. This encoding simplifies
the use of algorithms that require numerical input.
-
Splitting the Data: To evaluate our model’s
performance accurately, we split the dataset into training
and testing sets. Using the
createDataPartition function from the
caret package, we allocate 75% of the data for
training and reserve 25% for testing. This split is based on
the diagnosis column to ensure that both sets are
representative of the overall dataset.
-
Reproducibility: We set a seed before
splitting the data to ensure that our results are
reproducible. This step is crucial for scientific rigor and
allows others to replicate our analysis exactly.
The following code snippet illustrates these steps:
breast_cancer <- read_csv("cancer_de_mama.csv")
breast_cancer$diagnosis <- ifelse(breast_cancer$diagnosis == "M", 1, 0)
# Create indices for a 75% train and 25% test split
set.seed(123) # Setting seed for reproducibility
trainIndex <- createDataPartition(breast_cancer$diagnosis, p = 0.75,
list = FALSE,
times = 1)
# Split the data into training and testing sets
trainSet <- breast_cancer[trainIndex, ]
testSet <- breast_cancer[-trainIndex, ]
head(breast_cancer)
## # A tibble: 6 × 31
## diagnosis radius_mean texture_mean perimeter_mean area_mean smoothness_mean
## <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 1 18.0 10.4 123. 1001 0.118
## 2 1 20.6 17.8 133. 1326 0.0847
## 3 1 19.7 21.2 130 1203 0.110
## 4 1 11.4 20.4 77.6 386. 0.142
## 5 1 20.3 14.3 135. 1297 0.100
## 6 1 12.4 15.7 82.6 477. 0.128
## # ℹ 25 more variables: compactness_mean <dbl>, concavity_mean <dbl>,
## # `concave points_mean` <dbl>, symmetry_mean <dbl>,
## # fractal_dimension_mean <dbl>, radius_se <dbl>, texture_se <dbl>,
## # perimeter_se <dbl>, area_se <dbl>, smoothness_se <dbl>,
## # compactness_se <dbl>, concavity_se <dbl>, `concave points_se` <dbl>,
## # symmetry_se <dbl>, fractal_dimension_se <dbl>, radius_worst <dbl>,
## # texture_worst <dbl>, perimeter_worst <dbl>, area_worst <dbl>, …
3. Clean Data
After splitting the breast_cancer dataset into
training and testing sets, further refinements are made to
ensure smooth model training and evaluation:
-
Standardizing Variable Names: To prevent
potential issues with variable names that might not conform
to R’s variable naming conventions (such as spaces or
special characters), we use make.names with the
unique = TRUE parameter. This function modifies
the names in both training and testing datasets to ensure
they are valid R identifiers and unique. This step is
crucial for avoiding errors during model training and
evaluation.
-
Preparing a Blind Testing Set: To evaluate
the model’s predictive performance objectively, we create a
‘blind’ testing set. This version of the testing set
excludes the diagnosis column, which is the
outcome variable our model aims to predict. The absence of
this variable ensures that our model predictions are made
without access to the true outcomes, mimicking a real-world
scenario where the model would be used to predict unknown
cases.
The code modifications applied to the variable names and the
preparation of the blind testing set are foundational for the
subsequent modeling steps. They help in ensuring that our
analysis pipeline is robust and that the evaluation of the
model’s performance is as realistic as possible.
names(trainSet) <- make.names(names(trainSet), unique = TRUE)
names(testSet) <- make.names(names(trainSet), unique = TRUE)
testSetBlind <- subset(testSet, select = -diagnosis)
4. Generate Neural Network
With our data preprocessed and split into training and testing
sets, we proceed to train a neural network model. Our objective
is to predict the binary diagnosis outcome (malignant or benign)
based on a range of input features. The model is configured with
a single hidden layer consisting of five neurons, a setup aimed
at capturing the underlying complexities in the data without
overly complicating the model.
Following the model training, we visualize the neural network.
This visualization serves as a crucial step for understanding
the model’s structure, including how inputs are processed
through hidden layers to produce the final prediction. It
provides us with a graphical representation of the model,
showcasing the neurons, layers, and their interconnections.
This trained model and its visualization allow us to closely
examine the neural network’s architecture and better understand
the factors influencing its predictions. It sets the stage for
the next steps, where we will assess the model’s performance on
unseen data and gauge its predictive accuracy.
nn2 <- neuralnet(diagnosis ~ ., data=trainSet, hidden=c(5), linear.output=FALSE)
plot(nn2, rep="best")
5. Predict Results
After predicting the outcomes for our blind testing set using
the neural network model, we proceed to assess the model’s
performance through several key metrics: accuracy, recall, and
specificity. These metrics collectively offer a comprehensive
view of the model’s predictive capabilities:
-
Accuracy provides a high-level overview of
the model’s overall performance, indicating how often it
predicts correctly.
-
Recall is especially important in medical
diagnostics, as it measures the model’s ability to identify
all relevant cases of malignancy.
-
Specificity complements recall by assessing
the model’s proficiency in correctly identifying benign cases,
thus avoiding unnecessary alarm.
The computation of these metrics is based on a confusion matrix,
which contrasts the predicted labels against the actual labels
from the testing set. This analysis yields valuable insights
into the model’s strengths and areas for improvement, especially
in the context of breast cancer diagnosis where the balance
between sensitivity and specificity is critical.
prediction <- compute(nn2,testSetBlind)
predicted_labels <- ifelse(prediction$net.result > 0.5, 1, 0)
true_labels <- testSet$diagnosis
conf_matrix <- table(Predicted = predicted_labels, Actual = true_labels)
# Accuracy Metrics
accuracy <- sum(diag(conf_matrix)) / sum(conf_matrix)
recall <- conf_matrix[2,2] / sum(conf_matrix[2,])
specificity <- conf_matrix[1,1] / sum(conf_matrix[1,])
cat("Accuracy:", accuracy, "\n")
## Accuracy: 0.9859155
cat("Recall:", recall, "\n")
## Recall: 1
cat("Specificity:", specificity, "\n")
## Specificity: 0.9753086
---
title: "Redes Neuronales"
author: "David Dominguez - A01570975"
date: "2024-02-22"
output: 
  html_document: 
    toc: TRUE
    toc_float: TRUE
    code_download: TRUE
---

![](/Users/daviddrums180/Tec/ANN/1*-eLjPY7UGSoQhSyW5qC6gw.gif)

# Introduction to Artificial Neural Networks (ANN)

Artificial Neural Networks (ANN) are computing systems inspired by the biological neural networks of animal brains. These models are designed to simulate the way the human brain processes information, making them exceptionally good at modeling and solving complex problems by learning from data.

## Applications of ANNs

ANNs are applied in a wide range of real-world scenarios, some of which include:

- **Netflix content recommendation**: Uses ANNs to analyze your viewing history and preferences to recommend movies and shows you're likely to enjoy.
- **Instagram feed**: Employs deep learning algorithms to personalize your feed, showing you content that is more relevant to your interests.
- **Handwritten digit recognition**: ANNs can identify and classify handwritten numbers, a technology used in document digitization and character recognition.
- **FaceID technology**: Utilizes advanced ANNs for secure and accurate facial recognition, allowing you to unlock your device by simply looking at it.

These examples demonstrate the versatility and the ability of ANNs to learn from large datasets and perform tasks that would require human intelligence.

## Exercise 1: Did I Pass the Subject?

This exercise focuses on using an ANN to predict whether a student has passed a subject based on their academic features, such as grades obtained in assignments, midterm exams, and class attendance.

## <span style="color: blue;">1. Install Packages and Call Libraries</span>
Before we start working with artificial neural networks in R, it's crucial to have the `neuralnet` package installed and loaded. This package allows us to efficiently train and simulate artificial neural networks in R with a relatively straightforward syntax. The following code chunk first checks if the `neuralnet` package is installed, installing it if necessary. Then, it loads the package using `library(neuralnet)`, enabling us to access its functions and use them in our analysis.

Ensure you have an active internet connection if you need to install the package, as `install.packages` will download the package from CRAN.


```{r}
# install.packages("dplyr")
# install.packages("neuralnet")
library(dplyr)
library(neuralnet)
```

## <span style="color: blue;">2. Obtain Data</span>
We are constructing a data frame named `df` that contains three columns: `exam`, `proyect`, and `status`. Each of these columns represents different aspects of a dataset that could be related to student assessments or project evaluations:

- The `exam` column contains numeric scores or values associated with exams, with each entry representing a different individual or instance.

- The `proyect` column (presumably intended to spell "project") includes scores or values related to projects. Like the `exam` column, each entry here pertains to a different individual or instance.

- The `status` column uses binary values (1 or 0) to indicate a particular state or condition for each entry. This could represent a pass/fail status, completion, or any other binary indicator relevant to the context of the data.

The code below combines these vectors into a single data frame, providing a structured and tabular representation of the data for further analysis or visualization.


```{r}
exam<-c(20,10,30,20,80,30)
proyect<-c(90,20,40,50,50,80)
status<-c(1,0,0,0,0,1)

df<-data.frame(exam,proyect,status)
```

## <span style="color: blue;">3. Generate Neural Network</span>
We're applying a neural network model to predict the `status` based on `exam` and `proyect` scores using the `neuralnet` package. This model helps us understand the relationship between exam/project scores and their status outcomes. After training the model with `nn1 <- neuralnet(status ~., data=df)`, we visualize it using `plot(nn1, rep="best")` to inspect the network structure and how inputs are related to the prediction.

```{r}
nn1 <- neuralnet(status ~., data=df)
plot(nn1, rep="best")
```

## <span style="color: blue;">4. Predict Results</span>
Now that our neural network model is trained, we proceed to evaluate its predictive performance using a new set of exam and project scores. This step is essential for assessing the model's ability to generalize and make accurate predictions on data it hasn't seen before. By inputting these new scores into the model, we aim to predict their corresponding statuses, providing insights into how well our model can apply learned patterns to real-world or hypothetical scenarios. This evaluation phase is crucial for understanding the practical applicability of our neural network in predicting outcomes based on exam and project performances.


```{r}
exam_test<-c(30,40,85)
proyect_test<-c(85,50,40)
test1 <- data_frame(exam_test,proyect_test)
prediction <- compute(nn1,test1)

prediction$net.result
```

## <span style="color: red;">1. Install Packages and Call Libraries</span>
Before diving into our analysis, it's crucial to ensure that all necessary packages are installed and loaded into our R environment. This step lays the groundwork for a smooth analysis process, allowing us to utilize various functions and tools provided by these packages. Specifically, we focus on two packages:

- **`readr`**: Facilitates efficient reading of rectangular data, such as CSV files. Its fast and friendly syntax makes it a go-to choice for data import in R.
- **`caret`**: Stands for *Classification And REgression Training*. This package provides a comprehensive suite of tools to create complex predictive models. It simplifies the process of training and tuning machine learning models, making it invaluable for predictive analytics.

By loading these libraries, we ensure that our R session is equipped with the necessary tools for data importation, preprocessing, and advanced modeling techniques.

```{r message=FALSE, warning=FALSE}
# install.packages("readr")
# install.packages("caret")
library(readr)
library(caret)
```

## <span style="color: red;">2. Obtain Data</span>
After setting up our environment with the necessary libraries, our next step involves loading and preparing the dataset for analysis. We're focusing on a dataset named `cancer_de_mama.csv`, which includes data pertinent to breast cancer diagnosis. The preparation process involves several key steps to ensure the data is suitable for training a machine learning model:

- **Loading the Dataset**: We use the `read_csv` function from the `readr` package to load the `cancer_de_mama.csv` file. This function is optimized for fast and efficient loading of CSV files into R.

- **Encoding the Diagnosis**: The dataset includes a diagnosis column with categorical values (`M` for malignant, `B` for benign). We convert these into binary numeric values (1 for malignant, 0 for benign) to facilitate the modeling process. This encoding simplifies the use of algorithms that require numerical input.

- **Splitting the Data**: To evaluate our model's performance accurately, we split the dataset into training and testing sets. Using the `createDataPartition` function from the `caret` package, we allocate 75% of the data for training and reserve 25% for testing. This split is based on the diagnosis column to ensure that both sets are representative of the overall dataset.

- **Reproducibility**: We set a seed before splitting the data to ensure that our results are reproducible. This step is crucial for scientific rigor and allows others to replicate our analysis exactly.

The following code snippet illustrates these steps:

```{r message=FALSE, warning=FALSE}
breast_cancer <- read_csv("cancer_de_mama.csv")
breast_cancer$diagnosis <- ifelse(breast_cancer$diagnosis == "M", 1, 0)

# Create indices for a 75% train and 25% test split
set.seed(123) # Setting seed for reproducibility
trainIndex <- createDataPartition(breast_cancer$diagnosis, p = 0.75, 
                                  list = FALSE, 
                                  times = 1)

# Split the data into training and testing sets
trainSet <- breast_cancer[trainIndex, ]
testSet <- breast_cancer[-trainIndex, ]

head(breast_cancer)
```

## <span style="color: red;">3. Clean Data</span>
After splitting the `breast_cancer` dataset into training and testing sets, further refinements are made to ensure smooth model training and evaluation:

- **Standardizing Variable Names**: To prevent potential issues with variable names that might not conform to R's variable naming conventions (such as spaces or special characters), we use `make.names` with the `unique = TRUE` parameter. This function modifies the names in both training and testing datasets to ensure they are valid R identifiers and unique. This step is crucial for avoiding errors during model training and evaluation.

- **Preparing a Blind Testing Set**: To evaluate the model's predictive performance objectively, we create a 'blind' testing set. This version of the testing set excludes the `diagnosis` column, which is the outcome variable our model aims to predict. The absence of this variable ensures that our model predictions are made without access to the true outcomes, mimicking a real-world scenario where the model would be used to predict unknown cases.

The code modifications applied to the variable names and the preparation of the blind testing set are foundational for the subsequent modeling steps. They help in ensuring that our analysis pipeline is robust and that the evaluation of the model's performance is as realistic as possible.

```{r}
names(trainSet) <- make.names(names(trainSet), unique = TRUE)

names(testSet) <- make.names(names(trainSet), unique = TRUE)
testSetBlind <- subset(testSet, select = -diagnosis)
```


## <span style="color: red;">3. Generate Neural Network</span>
With our data preprocessed and split into training and testing sets, we proceed to train a neural network model. Our objective is to predict the binary diagnosis outcome (malignant or benign) based on a range of input features. The model is configured with a single hidden layer consisting of five neurons, a setup aimed at capturing the underlying complexities in the data without overly complicating the model.

Following the model training, we visualize the neural network. This visualization serves as a crucial step for understanding the model's structure, including how inputs are processed through hidden layers to produce the final prediction. It provides us with a graphical representation of the model, showcasing the neurons, layers, and their interconnections.

This trained model and its visualization allow us to closely examine the neural network's architecture and better understand the factors influencing its predictions. It sets the stage for the next steps, where we will assess the model's performance on unseen data and gauge its predictive accuracy.
```{r}
nn2 <- neuralnet(diagnosis ~ ., data=trainSet, hidden=c(5), linear.output=FALSE)
plot(nn2, rep="best")
```

## <span style="color: blue;">4. Predict Results</span>
After predicting the outcomes for our blind testing set using the neural network model, we proceed to assess the model's performance through several key metrics: accuracy, recall, and specificity. These metrics collectively offer a comprehensive view of the model's predictive capabilities:

- **Accuracy** provides a high-level overview of the model's overall performance, indicating how often it predicts correctly.
- **Recall** is especially important in medical diagnostics, as it measures the model's ability to identify all relevant cases of malignancy.
- **Specificity** complements recall by assessing the model's proficiency in correctly identifying benign cases, thus avoiding unnecessary alarm.

The computation of these metrics is based on a confusion matrix, which contrasts the predicted labels against the actual labels from the testing set. This analysis yields valuable insights into the model's strengths and areas for improvement, especially in the context of breast cancer diagnosis where the balance between sensitivity and specificity is critical.

```{r}
prediction <- compute(nn2,testSetBlind)

predicted_labels <- ifelse(prediction$net.result > 0.5, 1, 0)
true_labels <- testSet$diagnosis
conf_matrix <- table(Predicted = predicted_labels, Actual = true_labels)

# Accuracy Metrics
accuracy <- sum(diag(conf_matrix)) / sum(conf_matrix)
recall <- conf_matrix[2,2] / sum(conf_matrix[2,])
specificity <- conf_matrix[1,1] / sum(conf_matrix[1,])

cat("Accuracy:", accuracy, "\n")
cat("Recall:", recall, "\n")
cat("Specificity:", specificity, "\n")
```
